home *** CD-ROM | disk | FTP | other *** search
/ Dynamic HTML Construction Kit / Dynamic HTML Construction Kit.iso / earthlink / nscomm / java40.jar / java / awt / GridBagLayout.class (.txt) < prev    next >
Encoding:
Java Class File  |  1997-11-03  |  8.5 KB  |  699 lines
  1. package java.awt;
  2.  
  3. import java.util.Hashtable;
  4.  
  5. public class GridBagLayout implements LayoutManager {
  6.    protected static final int MAXGRIDSIZE = 128;
  7.    protected static final int MINSIZE = 1;
  8.    protected static final int PREFERREDSIZE = 2;
  9.    protected Hashtable comptable = new Hashtable();
  10.    protected GridBagConstraints defaultConstraints = new GridBagConstraints();
  11.    protected GridBagLayoutInfo layoutInfo;
  12.    public int[] columnWidths;
  13.    public int[] rowHeights;
  14.    public double[] columnWeights;
  15.    public double[] rowWeights;
  16.  
  17.    public void setConstraints(Component var1, GridBagConstraints var2) {
  18.       this.comptable.put(var1, var2.clone());
  19.    }
  20.  
  21.    public GridBagConstraints getConstraints(Component var1) {
  22.       GridBagConstraints var2 = (GridBagConstraints)this.comptable.get(var1);
  23.       if (var2 == null) {
  24.          this.setConstraints(var1, this.defaultConstraints);
  25.          var2 = (GridBagConstraints)this.comptable.get(var1);
  26.       }
  27.  
  28.       return (GridBagConstraints)var2.clone();
  29.    }
  30.  
  31.    protected GridBagConstraints lookupConstraints(Component var1) {
  32.       GridBagConstraints var2 = (GridBagConstraints)this.comptable.get(var1);
  33.       if (var2 == null) {
  34.          this.setConstraints(var1, this.defaultConstraints);
  35.          var2 = (GridBagConstraints)this.comptable.get(var1);
  36.       }
  37.  
  38.       return var2;
  39.    }
  40.  
  41.    public Point getLayoutOrigin() {
  42.       Point var1 = new Point(0, 0);
  43.       if (this.layoutInfo != null) {
  44.          var1.x = this.layoutInfo.startx;
  45.          var1.y = this.layoutInfo.starty;
  46.       }
  47.  
  48.       return var1;
  49.    }
  50.  
  51.    public int[][] getLayoutDimensions() {
  52.       if (this.layoutInfo == null) {
  53.          return new int[2][0];
  54.       } else {
  55.          int[][] var1 = new int[][]{new int[this.layoutInfo.width], new int[this.layoutInfo.height]};
  56.          System.arraycopy(this.layoutInfo.minWidth, 0, var1[0], 0, this.layoutInfo.width);
  57.          System.arraycopy(this.layoutInfo.minHeight, 0, var1[1], 0, this.layoutInfo.height);
  58.          return var1;
  59.       }
  60.    }
  61.  
  62.    public double[][] getLayoutWeights() {
  63.       if (this.layoutInfo == null) {
  64.          return new double[2][0];
  65.       } else {
  66.          double[][] var1 = new double[][]{new double[this.layoutInfo.width], new double[this.layoutInfo.height]};
  67.          System.arraycopy(this.layoutInfo.weightX, 0, var1[0], 0, this.layoutInfo.width);
  68.          System.arraycopy(this.layoutInfo.weightY, 0, var1[1], 0, this.layoutInfo.height);
  69.          return var1;
  70.       }
  71.    }
  72.  
  73.    public Point location(int var1, int var2) {
  74.       Point var3 = new Point(0, 0);
  75.       if (this.layoutInfo == null) {
  76.          return var3;
  77.       } else {
  78.          int var5 = this.layoutInfo.startx;
  79.  
  80.          int var4;
  81.          for(var4 = 0; var4 < this.layoutInfo.width; ++var4) {
  82.             var5 += this.layoutInfo.minWidth[var4];
  83.             if (var5 > var1) {
  84.                break;
  85.             }
  86.          }
  87.  
  88.          var3.x = var4;
  89.          var5 = this.layoutInfo.starty;
  90.  
  91.          for(var4 = 0; var4 < this.layoutInfo.height; ++var4) {
  92.             var5 += this.layoutInfo.minHeight[var4];
  93.             if (var5 > var2) {
  94.                break;
  95.             }
  96.          }
  97.  
  98.          var3.y = var4;
  99.          return var3;
  100.       }
  101.    }
  102.  
  103.    public void addLayoutComponent(String var1, Component var2) {
  104.    }
  105.  
  106.    public void removeLayoutComponent(Component var1) {
  107.    }
  108.  
  109.    public Dimension preferredLayoutSize(Container var1) {
  110.       GridBagLayoutInfo var2 = this.GetLayoutInfo(var1, 2);
  111.       return this.GetMinSize(var1, var2);
  112.    }
  113.  
  114.    public Dimension minimumLayoutSize(Container var1) {
  115.       GridBagLayoutInfo var2 = this.GetLayoutInfo(var1, 1);
  116.       return this.GetMinSize(var1, var2);
  117.    }
  118.  
  119.    public void layoutContainer(Container var1) {
  120.       this.ArrangeGrid(var1);
  121.    }
  122.  
  123.    public String toString() {
  124.       return this.getClass().getName();
  125.    }
  126.  
  127.    protected void DumpLayoutInfo(GridBagLayoutInfo var1) {
  128.       System.out.println("Col\tWidth\tWeight");
  129.  
  130.       for(int var2 = 0; var2 < var1.width; ++var2) {
  131.          System.out.println(var2 + "\t" + var1.minWidth[var2] + "\t" + var1.weightX[var2]);
  132.       }
  133.  
  134.       System.out.println("Row\tHeight\tWeight");
  135.  
  136.       for(int var3 = 0; var3 < var1.height; ++var3) {
  137.          System.out.println(var3 + "\t" + var1.minHeight[var3] + "\t" + var1.weightY[var3]);
  138.       }
  139.  
  140.    }
  141.  
  142.    protected void DumpConstraints(GridBagConstraints var1) {
  143.       System.out.println("wt " + var1.weightx + " " + var1.weighty + ", " + "box " + var1.gridx + " " + var1.gridy + " " + var1.gridwidth + " " + var1.gridheight + ", " + "min " + var1.minWidth + " " + var1.minHeight + ", " + "pad " + var1.insets.bottom + " " + var1.insets.left + " " + var1.insets.right + " " + var1.insets.top + " " + var1.ipadx + " " + var1.ipady);
  144.    }
  145.  
  146.    protected GridBagLayoutInfo GetLayoutInfo(Container var1, int var2) {
  147.       GridBagLayoutInfo var3 = new GridBagLayoutInfo();
  148.       int var7 = var1.countComponents();
  149.       var3.width = var3.height = 0;
  150.       int var20 = -1;
  151.       int var19 = -1;
  152.       int[] var25 = new int[128];
  153.       int[] var26 = new int[128];
  154.  
  155.       for(int var8 = 0; var8 < var7; ++var8) {
  156.          Component var4 = var1.getComponent(var8);
  157.          GridBagConstraints var5 = this.lookupConstraints(var4);
  158.          int var15 = var5.gridx;
  159.          int var16 = var5.gridy;
  160.          int var17 = var5.gridwidth;
  161.          if (var17 <= 0) {
  162.             var17 = 1;
  163.          }
  164.  
  165.          int var18 = var5.gridheight;
  166.          if (var18 <= 0) {
  167.             var18 = 1;
  168.          }
  169.  
  170.          if (var15 < 0 && var16 < 0) {
  171.             if (var19 >= 0) {
  172.                var16 = var19;
  173.             } else if (var20 >= 0) {
  174.                var15 = var20;
  175.             } else {
  176.                var16 = 0;
  177.             }
  178.          }
  179.  
  180.          if (var15 < 0) {
  181.             int var11 = 0;
  182.  
  183.             for(int var9 = var16; var9 < var16 + var18; ++var9) {
  184.                var11 = Math.max(var11, var25[var9]);
  185.             }
  186.  
  187.             var15 = var11 - var15 - 1;
  188.             if (var15 < 0) {
  189.                var15 = 0;
  190.             }
  191.          } else if (var16 < 0) {
  192.             int var12 = 0;
  193.  
  194.             for(int var37 = var15; var37 < var15 + var17; ++var37) {
  195.                var12 = Math.max(var12, var26[var37]);
  196.             }
  197.  
  198.             var16 = var12 - var16 - 1;
  199.             if (var16 < 0) {
  200.                var16 = 0;
  201.             }
  202.          }
  203.  
  204.          int var60;
  205.          for(var60 = var15 + var17; var3.width < var60; ++var3.width) {
  206.          }
  207.  
  208.          int var64;
  209.          for(var64 = var16 + var18; var3.height < var64; ++var3.height) {
  210.          }
  211.  
  212.          for(int var38 = var15; var38 < var15 + var17; ++var38) {
  213.             var26[var38] = var64;
  214.          }
  215.  
  216.          for(int var39 = var16; var39 < var16 + var18; ++var39) {
  217.             var25[var39] = var60;
  218.          }
  219.  
  220.          Dimension var6;
  221.          if (var2 == 2) {
  222.             var6 = var4.preferredSize();
  223.          } else {
  224.             var6 = var4.minimumSize();
  225.          }
  226.  
  227.          var5.minWidth = var6.width;
  228.          var5.minHeight = var6.height;
  229.          if (var5.gridheight == 0 && var5.gridwidth == 0) {
  230.             var20 = -1;
  231.             var19 = -1;
  232.          }
  233.  
  234.          if (var5.gridheight == 0 && var19 < 0) {
  235.             var20 = var15 + var17;
  236.          } else if (var5.gridwidth == 0 && var20 < 0) {
  237.             var19 = var16 + var18;
  238.          }
  239.       }
  240.  
  241.       if (this.columnWidths != null && var3.width < this.columnWidths.length) {
  242.          var3.width = this.columnWidths.length;
  243.       }
  244.  
  245.       if (this.rowHeights != null && var3.height < this.rowHeights.length) {
  246.          var3.height = this.rowHeights.length;
  247.       }
  248.  
  249.       var20 = -1;
  250.       var19 = -1;
  251.       var25 = new int[128];
  252.       var26 = new int[128];
  253.  
  254.       for(int var35 = 0; var35 < var7; ++var35) {
  255.          Component var31 = var1.getComponent(var35);
  256.          GridBagConstraints var33 = this.lookupConstraints(var31);
  257.          int var69 = var33.gridx;
  258.          int var70 = var33.gridy;
  259.          int var71 = var33.gridwidth;
  260.          int var72 = var33.gridheight;
  261.          if (var69 < 0 && var70 < 0) {
  262.             if (var19 >= 0) {
  263.                var70 = var19;
  264.             } else if (var20 >= 0) {
  265.                var69 = var20;
  266.             } else {
  267.                var70 = 0;
  268.             }
  269.          }
  270.  
  271.          if (var69 < 0) {
  272.             if (var72 <= 0) {
  273.                var72 += var3.height - var70;
  274.                if (var72 < 1) {
  275.                   var72 = 1;
  276.                }
  277.             }
  278.  
  279.             int var61 = 0;
  280.  
  281.             for(int var40 = var70; var40 < var70 + var72; ++var40) {
  282.                var61 = Math.max(var61, var25[var40]);
  283.             }
  284.  
  285.             var69 = var61 - var69 - 1;
  286.             if (var69 < 0) {
  287.                var69 = 0;
  288.             }
  289.          } else if (var70 < 0) {
  290.             if (var71 <= 0) {
  291.                var71 += var3.width - var69;
  292.                if (var71 < 1) {
  293.                   var71 = 1;
  294.                }
  295.             }
  296.  
  297.             int var65 = 0;
  298.  
  299.             for(int var41 = var69; var41 < var69 + var71; ++var41) {
  300.                var65 = Math.max(var65, var26[var41]);
  301.             }
  302.  
  303.             var70 = var65 - var70 - 1;
  304.             if (var70 < 0) {
  305.                var70 = 0;
  306.             }
  307.          }
  308.  
  309.          if (var71 <= 0) {
  310.             var71 += var3.width - var69;
  311.             if (var71 < 1) {
  312.                var71 = 1;
  313.             }
  314.          }
  315.  
  316.          if (var72 <= 0) {
  317.             var72 += var3.height - var70;
  318.             if (var72 < 1) {
  319.                var72 = 1;
  320.             }
  321.          }
  322.  
  323.          int var62 = var69 + var71;
  324.          int var66 = var70 + var72;
  325.  
  326.          for(int var42 = var69; var42 < var69 + var71; ++var42) {
  327.             var26[var42] = var66;
  328.          }
  329.  
  330.          for(int var43 = var70; var43 < var70 + var72; ++var43) {
  331.             var25[var43] = var62;
  332.          }
  333.  
  334.          if (var33.gridheight == 0 && var33.gridwidth == 0) {
  335.             var20 = -1;
  336.             var19 = -1;
  337.          }
  338.  
  339.          if (var33.gridheight == 0 && var19 < 0) {
  340.             var20 = var69 + var71;
  341.          } else if (var33.gridwidth == 0 && var20 < 0) {
  342.             var19 = var70 + var72;
  343.          }
  344.  
  345.          var33.tempX = var69;
  346.          var33.tempY = var70;
  347.          var33.tempWidth = var71;
  348.          var33.tempHeight = var72;
  349.       }
  350.  
  351.       int var14 = Integer.MAX_VALUE;
  352.  
  353.       for(int var44 = 1; var44 != Integer.MAX_VALUE; var14 = Integer.MAX_VALUE) {
  354.          for(int var36 = 0; var36 < var7; ++var36) {
  355.             Component var32 = var1.getComponent(var36);
  356.             GridBagConstraints var34 = this.lookupConstraints(var32);
  357.             if (var34.tempWidth != var44) {
  358.                if (var34.tempWidth > var44 && var34.tempWidth < var14) {
  359.                   var14 = var34.tempWidth;
  360.                }
  361.             } else {
  362.                int var63 = var34.tempX + var34.tempWidth;
  363.                double var21 = var34.weightx;
  364.  
  365.                for(int var10 = var34.tempX; var10 < var63; ++var10) {
  366.                   var21 -= var3.weightX[var10];
  367.                }
  368.  
  369.                if (var21 > (double)0.0F) {
  370.                   double var23 = (double)0.0F;
  371.  
  372.                   for(int var49 = var34.tempX; var49 < var63; ++var49) {
  373.                      var23 += var3.weightX[var49];
  374.                   }
  375.  
  376.                   for(int var50 = var34.tempX; var23 > (double)0.0F; ++var50) {
  377.                      double var27 = var3.weightX[var50];
  378.                      double var29 = var27 * var21 / var23;
  379.                      double[] var10000 = var3.weightX;
  380.                      var10000[var50] += var29;
  381.                      var21 -= var29;
  382.                      var23 -= var27;
  383.                   }
  384.  
  385.                   double[] var87 = var3.weightX;
  386.                   var87[var63 - 1] += var21;
  387.                }
  388.  
  389.                int var13 = var34.minWidth + var34.ipadx + var34.insets.left + var34.insets.right;
  390.  
  391.                for(int var51 = var34.tempX; var51 < var63; ++var51) {
  392.                   var13 -= var3.minWidth[var51];
  393.                }
  394.  
  395.                if (var13 > 0) {
  396.                   double var76 = (double)0.0F;
  397.  
  398.                   for(int var52 = var34.tempX; var52 < var63; ++var52) {
  399.                      var76 += var3.weightX[var52];
  400.                   }
  401.  
  402.                   for(int var53 = var34.tempX; var76 > (double)0.0F; ++var53) {
  403.                      double var81 = var3.weightX[var53];
  404.                      int var84 = (int)(var81 * (double)var13 / var76);
  405.                      int[] var88 = var3.minWidth;
  406.                      var88[var53] += var84;
  407.                      var13 -= var84;
  408.                      var76 -= var81;
  409.                   }
  410.  
  411.                   int[] var89 = var3.minWidth;
  412.                   var89[var63 - 1] += var13;
  413.                }
  414.             }
  415.  
  416.             if (var34.tempHeight != var44) {
  417.                if (var34.tempHeight > var44 && var34.tempHeight < var14) {
  418.                   var14 = var34.tempHeight;
  419.                }
  420.             } else {
  421.                int var67 = var34.tempY + var34.tempHeight;
  422.                double var75 = var34.weighty;
  423.  
  424.                for(int var54 = var34.tempY; var54 < var67; ++var54) {
  425.                   var75 -= var3.weightY[var54];
  426.                }
  427.  
  428.                if (var75 > (double)0.0F) {
  429.                   double var77 = (double)0.0F;
  430.  
  431.                   for(int var55 = var34.tempY; var55 < var67; ++var55) {
  432.                      var77 += var3.weightY[var55];
  433.                   }
  434.  
  435.                   for(int var56 = var34.tempY; var77 > (double)0.0F; ++var56) {
  436.                      double var82 = var3.weightY[var56];
  437.                      double var85 = var82 * var75 / var77;
  438.                      double[] var90 = var3.weightY;
  439.                      var90[var56] += var85;
  440.                      var75 -= var85;
  441.                      var77 -= var82;
  442.                   }
  443.  
  444.                   double[] var91 = var3.weightY;
  445.                   var91[var67 - 1] += var75;
  446.                }
  447.  
  448.                int var68 = var34.minHeight + var34.ipady + var34.insets.top + var34.insets.bottom;
  449.  
  450.                for(int var57 = var34.tempY; var57 < var67; ++var57) {
  451.                   var68 -= var3.minHeight[var57];
  452.                }
  453.  
  454.                if (var68 > 0) {
  455.                   double var78 = (double)0.0F;
  456.  
  457.                   for(int var58 = var34.tempY; var58 < var67; ++var58) {
  458.                      var78 += var3.weightY[var58];
  459.                   }
  460.  
  461.                   for(int var59 = var34.tempY; var78 > (double)0.0F; ++var59) {
  462.                      double var83 = var3.weightY[var59];
  463.                      int var86 = (int)(var83 * (double)var68 / var78);
  464.                      int[] var92 = var3.minHeight;
  465.                      var92[var59] += var86;
  466.                      var68 -= var86;
  467.                      var78 -= var83;
  468.                   }
  469.  
  470.                   int[] var93 = var3.minHeight;
  471.                   var93[var67 - 1] += var68;
  472.                }
  473.             }
  474.          }
  475.  
  476.          var44 = var14;
  477.       }
  478.  
  479.       if (this.columnWidths != null) {
  480.          for(int var45 = 0; var45 < this.columnWidths.length; ++var45) {
  481.             if (var3.minWidth[var45] < this.columnWidths[var45]) {
  482.                var3.minWidth[var45] = this.columnWidths[var45];
  483.             }
  484.          }
  485.       }
  486.  
  487.       if (this.rowHeights != null) {
  488.          for(int var46 = 0; var46 < this.rowHeights.length; ++var46) {
  489.             if (var3.minHeight[var46] < this.rowHeights[var46]) {
  490.                var3.minHeight[var46] = this.rowHeights[var46];
  491.             }
  492.          }
  493.       }
  494.  
  495.       if (this.columnWeights != null) {
  496.          for(int var47 = 0; var47 < var3.width && var47 < this.columnWeights.length; ++var47) {
  497.             if (var3.weightX[var47] < this.columnWeights[var47]) {
  498.                var3.weightX[var47] = this.columnWeights[var47];
  499.             }
  500.          }
  501.       }
  502.  
  503.       if (this.rowWeights != null) {
  504.          for(int var48 = 0; var48 < var3.height && var48 < this.rowWeights.length; ++var48) {
  505.             if (var3.weightY[var48] < this.rowWeights[var48]) {
  506.                var3.weightY[var48] = this.rowWeights[var48];
  507.             }
  508.          }
  509.       }
  510.  
  511.       return var3;
  512.    }
  513.  
  514.    protected void AdjustForGravity(GridBagConstraints var1, Rectangle var2) {
  515.       var2.x += var1.insets.left;
  516.       var2.width -= var1.insets.left + var1.insets.right;
  517.       var2.y += var1.insets.top;
  518.       var2.height -= var1.insets.top + var1.insets.bottom;
  519.       int var3 = 0;
  520.       if (var1.fill != 2 && var1.fill != 1 && var2.width > var1.minWidth + var1.ipadx) {
  521.          var3 = var2.width - (var1.minWidth + var1.ipadx);
  522.          var2.width = var1.minWidth + var1.ipadx;
  523.       }
  524.  
  525.       int var4 = 0;
  526.       if (var1.fill != 3 && var1.fill != 1 && var2.height > var1.minHeight + var1.ipady) {
  527.          var4 = var2.height - (var1.minHeight + var1.ipady);
  528.          var2.height = var1.minHeight + var1.ipady;
  529.       }
  530.  
  531.       switch (var1.anchor) {
  532.          case 10:
  533.             var2.x += var3 / 2;
  534.             var2.y += var4 / 2;
  535.             return;
  536.          case 11:
  537.             var2.x += var3 / 2;
  538.             return;
  539.          case 12:
  540.             var2.x += var3;
  541.             return;
  542.          case 13:
  543.             var2.x += var3;
  544.             var2.y += var4 / 2;
  545.             return;
  546.          case 14:
  547.             var2.x += var3;
  548.             var2.y += var4;
  549.             return;
  550.          case 15:
  551.             var2.x += var3 / 2;
  552.             var2.y += var4;
  553.             return;
  554.          case 16:
  555.             var2.y += var4;
  556.             return;
  557.          case 17:
  558.             var2.y += var4 / 2;
  559.             return;
  560.          case 18:
  561.             return;
  562.          default:
  563.             throw new IllegalArgumentException("illegal anchor value");
  564.       }
  565.    }
  566.  
  567.    protected Dimension GetMinSize(Container var1, GridBagLayoutInfo var2) {
  568.       Dimension var3 = new Dimension();
  569.       Insets var6 = var1.insets();
  570.       int var5 = 0;
  571.  
  572.       for(int var4 = 0; var4 < var2.width; ++var4) {
  573.          var5 += var2.minWidth[var4];
  574.       }
  575.  
  576.       var3.width = var5 + var6.left + var6.right;
  577.       var5 = 0;
  578.  
  579.       for(int var7 = 0; var7 < var2.height; ++var7) {
  580.          var5 += var2.minHeight[var7];
  581.       }
  582.  
  583.       var3.height = var5 + var6.top + var6.bottom;
  584.       return var3;
  585.    }
  586.  
  587.    protected void ArrangeGrid(Container var1) {
  588.       Insets var5 = var1.insets();
  589.       int var6 = var1.countComponents();
  590.       Rectangle var8 = new Rectangle();
  591.       if (var6 != 0 || this.columnWidths != null && this.columnWidths.length != 0 || this.rowHeights != null && this.rowHeights.length != 0) {
  592.          GridBagLayoutInfo var14 = this.GetLayoutInfo(var1, 2);
  593.          Dimension var7 = this.GetMinSize(var1, var14);
  594.          if (var7.width < var1.width || var7.height < var1.height) {
  595.             var14 = this.GetLayoutInfo(var1, 1);
  596.             var7 = this.GetMinSize(var1, var14);
  597.          }
  598.  
  599.          this.layoutInfo = var14;
  600.          var8.width = var7.width;
  601.          var8.height = var7.height;
  602.          int var10 = var1.width - var8.width;
  603.          if (var10 != 0) {
  604.             double var12 = (double)0.0F;
  605.  
  606.             for(int var9 = 0; var9 < var14.width; ++var9) {
  607.                var12 += var14.weightX[var9];
  608.             }
  609.  
  610.             if (var12 > (double)0.0F) {
  611.                for(int var16 = 0; var16 < var14.width; ++var16) {
  612.                   int var15 = (int)((double)var10 * var14.weightX[var16] / var12);
  613.                   int[] var10000 = var14.minWidth;
  614.                   var10000[var16] += var15;
  615.                   var8.width += var15;
  616.                   if (var14.minWidth[var16] < 0) {
  617.                      var8.width -= var14.minWidth[var16];
  618.                      var14.minWidth[var16] = 0;
  619.                   }
  620.                }
  621.             }
  622.  
  623.             var10 = var1.width - var8.width;
  624.          } else {
  625.             var10 = 0;
  626.          }
  627.  
  628.          int var11 = var1.height - var8.height;
  629.          if (var11 != 0) {
  630.             double var25 = (double)0.0F;
  631.  
  632.             for(int var17 = 0; var17 < var14.height; ++var17) {
  633.                var25 += var14.weightY[var17];
  634.             }
  635.  
  636.             if (var25 > (double)0.0F) {
  637.                for(int var18 = 0; var18 < var14.height; ++var18) {
  638.                   int var26 = (int)((double)var11 * var14.weightY[var18] / var25);
  639.                   int[] var27 = var14.minHeight;
  640.                   var27[var18] += var26;
  641.                   var8.height += var26;
  642.                   if (var14.minHeight[var18] < 0) {
  643.                      var8.height -= var14.minHeight[var18];
  644.                      var14.minHeight[var18] = 0;
  645.                   }
  646.                }
  647.             }
  648.  
  649.             var11 = var1.height - var8.height;
  650.          } else {
  651.             var11 = 0;
  652.          }
  653.  
  654.          var14.startx = var10 / 2 + var5.left;
  655.          var14.starty = var11 / 2 + var5.top;
  656.  
  657.          for(int var3 = 0; var3 < var6; ++var3) {
  658.             Component var2 = var1.getComponent(var3);
  659.             GridBagConstraints var4 = this.lookupConstraints(var2);
  660.             var8.x = var14.startx;
  661.  
  662.             for(int var19 = 0; var19 < var4.tempX; ++var19) {
  663.                var8.x += var14.minWidth[var19];
  664.             }
  665.  
  666.             var8.y = var14.starty;
  667.  
  668.             for(int var20 = 0; var20 < var4.tempY; ++var20) {
  669.                var8.y += var14.minHeight[var20];
  670.             }
  671.  
  672.             var8.width = 0;
  673.  
  674.             for(int var21 = var4.tempX; var21 < var4.tempX + var4.tempWidth; ++var21) {
  675.                var8.width += var14.minWidth[var21];
  676.             }
  677.  
  678.             var8.height = 0;
  679.  
  680.             for(int var22 = var4.tempY; var22 < var4.tempY + var4.tempHeight; ++var22) {
  681.                var8.height += var14.minHeight[var22];
  682.             }
  683.  
  684.             this.AdjustForGravity(var4, var8);
  685.             if (var8.width > 0 && var8.height > 0) {
  686.                if (var2.x != var8.x || var2.y != var8.y || var2.width != var8.width || var2.height != var8.height) {
  687.                   var2.reshape(var8.x, var8.y, var8.width, var8.height);
  688.                }
  689.  
  690.                var2.show();
  691.             } else {
  692.                var2.hide();
  693.             }
  694.          }
  695.  
  696.       }
  697.    }
  698. }
  699.